package com.demo.mq.rabbitmq.config;

import org.springframework.amqp.core.*;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.ChannelAwareMessageListener;
import org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.rabbitmq.client.Channel;

/**
 * Rabbit配置
 *
 * @author lee9213@163.com
 * @version 1.0
 * @date 2017-04-04 14:54
 */
@Configuration
public class RabbitMQConfig {

    /*消息交换机的名字*/
    public static final String EXCHANGE = "my-mq-exchange";
    /*队列key1*/
    public static final String ROUTINGKEY1 = "queue-one-key1";
    /*队列key2*/
    public static final String ROUTINGKEY2 = "queue-one-key2";

    @Bean
    @ConfigurationProperties("spring.rabbitmq")
    public ConnectionFactory connectionFactory() {
        return new CachingConnectionFactory();
    }

    /**
     * 配置消息交换机
     * FanoutExchange：将消息发送到所有的绑定队列，无routingkey概念
     * HeadersExchange：通过添加属性key-value匹配
     * DirectExchange：按照routingkey分发到指定队列
     * TopicExchange：多关键字匹配
     *
     * @return
     */
    @Bean
    public DirectExchange defaultExchange() {
        return new DirectExchange(EXCHANGE, true, false);
    }

    /**
     * 消息队列1
     *
     * @return
     */
    @Bean
    public Queue queue() {
        return new Queue("queue_one", true);//队列持久
    }

    /**
     * 将消息队列1与交换机绑定
     *
     * @return
     */
    @Bean
    public Binding binding() {
        return BindingBuilder.bind(queue()).to(defaultExchange()).with(ROUTINGKEY1);
    }

    /**
     * 消息队列2
     *
     * @return
     */
    @Bean
    public Queue queue1() {
        return new Queue("queue_one1", true);//队列持久
    }

    /**
     * 将消息队列2与交换机绑定
     *
     * @return
     */
    @Bean
    public Binding binding1() {
        return BindingBuilder.bind(queue1()).to(defaultExchange()).with(ROUTINGKEY2);
    }

    /**
     * 接收消息队列1的消息的监听
     * @return
     */
    @Bean
    public SimpleMessageListenerContainer messageListenerContainer(){
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory());
        container.setQueues(queue());
        container.setExposeListenerChannel(true);
        container.setMaxConcurrentConsumers(1);
        container.setConcurrentConsumers(1);
        container.setAcknowledgeMode(AcknowledgeMode.MANUAL);
        container.setMessageListener(new ChannelAwareMessageListener() {
            @Override
            public void onMessage(Message message, Channel channel) throws Exception {
                byte[] body = message.getBody();
                System.out.println("接收到的消息："+new String(body));
                channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);//确认消息成功消费
            }
        });
        return container;
    }
    /**
     * 接收消息队列2的消息的监听
     * @return
     */
    @Bean
    public SimpleMessageListenerContainer messageListenerContainer1(){
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory());
        container.setQueues(queue1());
        container.setExposeListenerChannel(true);
        container.setMaxConcurrentConsumers(1);
        container.setConcurrentConsumers(1);
        container.setAcknowledgeMode(AcknowledgeMode.MANUAL);
        container.setMessageListener(new ChannelAwareMessageListener() {
            @Override
            public void onMessage(Message message, Channel channel) throws Exception {
                byte[] body = message.getBody();
                System.out.println("接收到的消息："+new String(body));
                channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);//确认消息成功消费
            }
        });
        return container;
    }
}
